home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Tool Chest / QuickDraw / Bitblitz 1.0 / Source / MainStuff.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-09  |  18.6 KB  |  679 lines  |  [TEXT/MPS ]
  1. /*--------------------------------------------------------------------------------------
  2. //
  3. //    File:          MainStuff.c
  4. //
  5. //    Contents:    Main event loop.  Only those portions needed for support of the tools 
  6. //                features have been included.
  7. //
  8. //
  9. //    By Georgiann ("George") Delaney
  10. //    © 1989 - 1990, Apple Computer, Inc.
  11. //
  12. //--------------------------------------------------------------------------------------*/
  13.  
  14.  
  15. #include "MacHeaders.h"
  16.  
  17. #include "BitBlitz.h"
  18. #include "MainStuff.h"
  19.  
  20.  
  21. #pragma segment main
  22.  
  23.  
  24.  
  25. /*======================================================================================*/
  26. /*  Shell Global Variables     */
  27.  
  28. Boolean        gFinished        = false;            /* Does the user want to quit the application?         */
  29.  
  30. Boolean        gWNEAvailable;                        /* Specifies if WaitNextEvent is available             */
  31. Boolean        gInBackground     = false;            /* Is the application in the background under MF      */ 
  32.  
  33. Handle        gtheMenuBar;                        /* Handle to the tool menus                         */
  34. MenuHandle    gtheMenus[kMenuCount+kHeirCount];    /* Structure holding the application menus             */    
  35.  
  36. short        gCmdOn            = false;            /* Is the command key being pressed?                 */
  37.  
  38. Boolean        gDoubleClick    = false;            /* Determines if the user double-clicked             */
  39. long        gLastTime;
  40. Point        gLastPoint;                            
  41.  
  42.  
  43.  
  44. /*======================================================================================*/
  45. /*    Setup Routines  */
  46.  
  47.  
  48.  
  49. /*--------------------------------------------------------------------------------------*/
  50. void SetUpMenu()
  51. /*
  52. //    This procedure reads in all of the menu resources and builds the application 
  53. //    menu.
  54. */
  55. {
  56.     short    n;
  57.  
  58.     InitMenus();
  59.     
  60.     gtheMenus[kAppleMenu]     = GetMenu( kAppleMenuID );
  61.     AddResMenu(gtheMenus[kAppleMenu],'DRVR');
  62.     
  63.     gtheMenus[kFileMenu]      = GetMenu(kFileMenuID);
  64.     gtheMenus[kEditMenu]      = GetMenu(kEditMenuID);
  65.     gtheMenus[kOptionsMenu]   = GetMenu(kOptionsMenuID);
  66.  
  67.      gtheMenus[khCopyModeMenu] = GetMenu(khCopyModeMenuID);
  68.      gtheMenus[khClipRgnMenu]  = GetMenu(khClipRgnMenuID);
  69.      gtheMenus[khVisRgnMenu]   = GetMenu(khVisRgnMenuID);
  70.      gtheMenus[khMaskRgnMenu]  = GetMenu(khMaskRgnMenuID);
  71.  
  72.      gtheMenus[khFGColorMenu]  = GetMenu(khFGColorMenuID);
  73.      gtheMenus[khBKColorMenu]  = GetMenu(khBKColorMenuID);
  74.      gtheMenus[khOPColorMenu]  = GetMenu(khOPColorMenuID);
  75.      gtheMenus[khHiliteMenu]   = GetMenu(khHiliteMenuID);
  76.  
  77.       for ( n = 0; n < kMenuCount; n++ ) 
  78.         InsertMenu(gtheMenus[n],0);
  79.  
  80.       for ( n = n; n < (kMenuCount+kHeirCount); n++ ) 
  81.         InsertMenu(gtheMenus[n], hierMenu);
  82.  
  83.     gtheMenuBar = GetMenuBar();  
  84.     DrawMenuBar();
  85. }
  86.  
  87.  
  88. /*--------------------------------------------------------------------------------------*/
  89. void InitAppMenus()
  90. {
  91.  
  92.     if (!gColorAvail)  {
  93.        DisableItem(gtheMenus[kOptionsMenu], kSrcOr );
  94.        DisableItem(gtheMenus[kOptionsMenu], kSrcXor );
  95.        DisableItem(gtheMenus[kOptionsMenu], kSrcBic );
  96.        DisableItem(gtheMenus[kOptionsMenu], kNotSrcCopy );
  97.        DisableItem(gtheMenus[kOptionsMenu], kNotSrcOr );
  98.        DisableItem(gtheMenus[kOptionsMenu], kNotSrcXor );
  99.        DisableItem(gtheMenus[kOptionsMenu], kNotSrcBic );
  100.        DisableItem(gtheMenus[kOptionsMenu], kBlend );
  101.        DisableItem(gtheMenus[kOptionsMenu], kAddPin );
  102.        DisableItem(gtheMenus[kOptionsMenu], kAddOver );
  103.        DisableItem(gtheMenus[kOptionsMenu], kAddMin );
  104.        DisableItem(gtheMenus[kOptionsMenu], kAddMax );
  105.        DisableItem(gtheMenus[kOptionsMenu], kSubPin );
  106.        DisableItem(gtheMenus[kOptionsMenu], kSubOver );
  107.        DisableItem(gtheMenus[kOptionsMenu], kTransparent );
  108.        DisableItem(gtheMenus[kOptionsMenu], kHilite );
  109.        }
  110.     else
  111.         CheckItem  (gtheMenus[khCopyModeMenu],CopyMode2ModeMenuItem(gCopyMode),true);
  112.  
  113. }
  114.  
  115. /*--------------------------------------------------------------------------------------*/
  116. void InitMac()
  117. /*
  118. //    This procedure executes all Macintosh initialization functions. 
  119. */
  120. {
  121.     EventRecord    theEvent;
  122.     
  123.     MaxApplZone();
  124.     MoreMasters();    MoreMasters();    MoreMasters();    MoreMasters();
  125.  
  126.     InitGraf(&qd.thePort);
  127.     InitFonts();
  128.     InitWindows();
  129.     SetUpMenu();
  130.     TEInit();
  131.     InitDialogs(nil);
  132.     InitCursor();
  133.     InitAllPacks();
  134.             
  135.     gWNEAvailable = myTrapAvailable(_WaitNextEvent, ToolTrap);
  136.  
  137.     EventAvail(everyEvent,&theEvent);    /* Force windows to front… (for MF) */
  138. }
  139.  
  140.  
  141.  
  142.  
  143. /*======================================================================================*/
  144. /*    Main Loop and Event Management Routines  */
  145.  
  146.  
  147. /*--------------------------------------------------------------------------------------*/
  148. Boolean IsDAWindow( window )
  149.     WindowPtr    window;
  150. {
  151.     if ( window == nil )
  152.         return false;
  153.     else    
  154.         return ( (WindowPeek) window)->windowKind < 0;
  155. } 
  156.  
  157.  
  158. /*--------------------------------------------------------------------------------------*/
  159. void AdjustMenusForDA()
  160. {
  161.     EnableItem (gtheMenus[kFileMenu], kNew);
  162.     EnableItem (gtheMenus[kFileMenu], kOpen);
  163.     EnableItem (gtheMenus[kFileMenu], kClose);
  164.     EnableItem (gtheMenus[kFileMenu], kSave);
  165.     EnableItem (gtheMenus[kFileMenu], kSaveAs);
  166.     EnableItem (gtheMenus[kFileMenu], kPageSetUp);
  167.     EnableItem (gtheMenus[kFileMenu], kPrint);
  168.     EnableItem (gtheMenus[kFileMenu], kQuit);
  169.  
  170.     EnableItem (gtheMenus[kEditMenu], kUndo);
  171.     EnableItem (gtheMenus[kEditMenu], kCut);
  172.     EnableItem (gtheMenus[kEditMenu], kCopy);
  173.     EnableItem (gtheMenus[kEditMenu], kPaste);
  174.     EnableItem (gtheMenus[kEditMenu], kClear);
  175.  
  176.     DisableItem(gtheMenus[kOptionsMenu], kSrcAttributes );
  177.     DisableItem(gtheMenus[kOptionsMenu], kMskAttributes );
  178.     DisableItem(gtheMenus[kOptionsMenu], kDstAttributes );
  179.     
  180.     DisableItem(gtheMenus[kOptionsMenu], kTrapSelect);
  181.     DisableItem(gtheMenus[kOptionsMenu], kCopyModeSelect);
  182.     DisableItem(gtheMenus[kOptionsMenu], kMaskRgnSelect);
  183. } 
  184.  
  185.  
  186. /*--------------------------------------------------------------------------------------*/
  187. void AdjustMenusForApp()
  188. {
  189.     DisableItem(gtheMenus[kFileMenu], kNew);
  190.     DisableItem(gtheMenus[kFileMenu], kOpen);
  191.     DisableItem(gtheMenus[kFileMenu], kClose);
  192.     DisableItem(gtheMenus[kFileMenu], kSave);
  193.     DisableItem(gtheMenus[kFileMenu], kSaveAs);
  194.     DisableItem(gtheMenus[kFileMenu], kPageSetUp);
  195.     DisableItem(gtheMenus[kFileMenu], kPrint);
  196.     EnableItem (gtheMenus[kFileMenu], kQuit);
  197.  
  198.     DisableItem(gtheMenus[kEditMenu], kUndo);
  199.     DisableItem(gtheMenus[kEditMenu], kCut);
  200.     DisableItem(gtheMenus[kEditMenu], kCopy);
  201.     DisableItem(gtheMenus[kEditMenu], kPaste);
  202.     DisableItem(gtheMenus[kEditMenu], kClear);
  203.  
  204.     EnableItem (gtheMenus[kOptionsMenu], kSrcAttributes );
  205.     EnableItem (gtheMenus[kOptionsMenu], kMskAttributes );
  206.     EnableItem (gtheMenus[kOptionsMenu], kDstAttributes );
  207.     
  208.     EnableItem (gtheMenus[kOptionsMenu], kTrapSelect);
  209.         
  210.     EnableItem (gtheMenus[kOptionsMenu],  kFGColor);
  211.     CheckItem  (gtheMenus[khFGColorMenu], gFGColor.menuIndex,    true);
  212.     
  213.     EnableItem (gtheMenus[kOptionsMenu],  kBKColor);
  214.     CheckItem  (gtheMenus[khBKColorMenu], gBKColor.menuIndex,    true);
  215.  
  216.     EnableItem (gtheMenus[kOptionsMenu],  kClipRgnSelect);
  217.     CheckItem  (gtheMenus[khClipRgnMenu], gRList[kClpRgn].type,    true);
  218.  
  219.     EnableItem (gtheMenus[kOptionsMenu],  kVisRgnSelect);
  220.     CheckItem  (gtheMenus[khVisRgnMenu],  gRList[kVisRgn].type,    true);
  221.  
  222.     EnableItem (gtheMenus[kOptionsMenu],  kUseScreenBits);
  223.     CheckItem  (gtheMenus[kOptionsMenu],  kUseScreenBits,          gUseScreenBits);
  224.  
  225.     EnableItem (gtheMenus[kOptionsMenu],  kDither);
  226.     CheckItem  (gtheMenus[kOptionsMenu],  kDither,              gDither);
  227.     
  228.     if (gColorAvail)  {
  229.         EnableItem (gtheMenus[kOptionsMenu], kOpColor);
  230.         CheckItem  (gtheMenus[khOPColorMenu],gOPColor.menuIndex,true);
  231.  
  232.         EnableItem (gtheMenus[kOptionsMenu], kHiliteColor);
  233.         CheckItem  (gtheMenus[khHiliteMenu], gHiliteColor.menuIndex,true);
  234.         }
  235.     else  {
  236.         DisableItem(gtheMenus[khFGColorMenu], kCustomColor);
  237.         DisableItem(gtheMenus[khFGColorMenu], kCustomColor);
  238.  
  239.         DisableItem(gtheMenus[kOptionsMenu], kOpColor);
  240.         DisableItem(gtheMenus[kOptionsMenu], kHiliteColor);
  241.         }
  242.     
  243.     if ((gTrapSelect == kCopyDeepMask) || (gTrapSelect == kCopyBits))  {
  244.         EnableItem (gtheMenus[kOptionsMenu],  kCopyModeSelect);
  245.         EnableItem (gtheMenus[kOptionsMenu],  kMaskRgnSelect);
  246.         CheckItem  (gtheMenus[khMaskRgnMenu], gRList[kMskRgn].type,true);
  247.  
  248.         if (gTrapSelect == kCopyBits)  
  249.             DisableItem(gtheMenus[kOptionsMenu], kMskAttributes );
  250.         }
  251.     else {
  252.         DisableItem(gtheMenus[kOptionsMenu], kCopyModeSelect);
  253.         DisableItem(gtheMenus[kOptionsMenu], kMaskRgnSelect);
  254.         }
  255. } 
  256.  
  257.  
  258. /*--------------------------------------------------------------------------------------*/
  259. void AdjustMenus()
  260. /*
  261.     AdjustMenus will properly activate/deactivate/update each menu item in each 
  262.     of the menus to properly reflect the available selections with respect to the
  263.     currently active window.
  264. */
  265. {
  266.     WindowPtr    theActiveWindow;
  267.     
  268.     theActiveWindow = FrontWindow();        
  269.     
  270.     if (IsDAWindow(theActiveWindow)) 
  271.          AdjustMenusForDA();
  272.     else AdjustMenusForApp(); 
  273. }
  274.  
  275.  
  276. /*--------------------------------------------------------------------------------------*/
  277. void DoMenuCommand(long    menuData)
  278. {
  279.     short        theMenu;
  280.     short        theItem;
  281.     Str255        theName;
  282.     short        theRefNum;
  283.     Boolean        imageChanged = true;
  284.     OSErr        result         = noErr;
  285.     
  286.     theMenu = HiWord(menuData);
  287.     theItem = LoWord(menuData);
  288.  
  289.     switch (theMenu)  {    
  290.         case kAppleMenuID:
  291.             switch ( theItem )  {
  292.                 case kAboutBox:        AboutBitBlitz();        break;
  293.                 default:
  294.                     GetItem(GetMHandle(kAppleMenuID), theItem, theName);
  295.                     theRefNum = OpenDeskAcc(theName);
  296.                     break;
  297.                 }
  298.             break;
  299.             
  300.         case kFileMenuID:
  301.             switch ( theItem )  {
  302.                 case kNew:            break;
  303.                 case kOpen:            break;
  304.                 case kClose:        break;
  305.                 case kSave:            break;
  306.                 case kSaveAs:        break;
  307.                 case kPageSetUp:    break;
  308.                 case kPrint:        break;
  309.                 case kQuit:            gFinished = true;        break;
  310.                 }
  311.             break;
  312.             
  313.         case kEditMenuID:
  314.             switch ( theItem )  {
  315.                 case kUndo:            break;
  316.                 case kCut:            break;
  317.                 case kCopy:            break;
  318.                 case kPaste:        break;
  319.                 case kClear:        break;
  320.                 }
  321.             break;
  322.  
  323.         case kOptionsMenuID:
  324.             switch ( theItem )  {
  325.                 case kSrcAttributes:  ChangeWindowAttributes(kSrcWindow);    break;
  326.                 case kMskAttributes:  ChangeWindowAttributes(kMskWindow);    break;
  327.                 case kDstAttributes:  ChangeWindowAttributes(kDstWindow);    break;
  328.                 case kTrapSelect:     SelectTrap();                             break;
  329.                 case kUseScreenBits:  gUseScreenBits = !gUseScreenBits;
  330.                                       CheckItem (gtheMenus[kOptionsMenu],kUseScreenBits,gUseScreenBits);
  331.                                       DrawBuffer(kBitWindow);
  332.                                       DrawWindow(kBitWindow);
  333.                                       break;
  334.                 case kDither:            gDither = !gDither;
  335.                                       CheckItem (gtheMenus[kOptionsMenu],kDither,gDither);
  336.                                       if ((gCopyMode == srcCopy) || (gCopyMode == ditherCopy)) {
  337.                                           if (gDither)
  338.                                             gCopyMode = ditherCopy;
  339.                                         else
  340.                                             gCopyMode = srcCopy;
  341.                                           }
  342.                                       DrawBuffer(kBitWindow);
  343.                                       DrawWindow(kBitWindow);
  344.                                       break;
  345.                 }
  346.             break;
  347.         
  348.         case khCopyModeMenuID:     
  349.             CheckItem(gtheMenus[khCopyModeMenu],CopyMode2ModeMenuItem(gCopyMode),false);
  350.             CheckItem(gtheMenus[khCopyModeMenu],theItem,true);
  351.             gCopyMode = ModeMenuItem2CopyMode(theItem);
  352.             DrawBuffer(kBitWindow);
  353.             DrawWindow(kBitWindow);
  354.             break;        
  355.  
  356.         case khClipRgnMenuID:     
  357.             CheckItem (gtheMenus[khClipRgnMenu],gRList[kClpRgn].type,false);
  358.             SelectRgn (kClpRgn,theItem);    
  359.             CheckItem (gtheMenus[khClipRgnMenu],gRList[kClpRgn].type,true);
  360.             break;        
  361.  
  362.         case khVisRgnMenuID:     
  363.             CheckItem (gtheMenus[khVisRgnMenu],gRList[kVisRgn].type,false);
  364.             SelectRgn (kVisRgn,theItem);    
  365.             CheckItem (gtheMenus[khVisRgnMenu],gRList[kVisRgn].type,true);
  366.             break;        
  367.  
  368.         case khMaskRgnMenuID:     
  369.             CheckItem (gtheMenus[khMaskRgnMenu],gRList[kMskRgn].type,false);
  370.             SelectRgn (kMskRgn,theItem);    
  371.             CheckItem (gtheMenus[khMaskRgnMenu],gRList[kMskRgn].type,true);
  372.             break;        
  373.  
  374.         case khFGColorMenuID:
  375.             CheckItem (gtheMenus[khFGColorMenu],gFGColor.menuIndex,false);
  376.             SelectFGColor(theItem);    
  377.             CheckItem (gtheMenus[khFGColorMenu],gFGColor.menuIndex,true);
  378.             break;
  379.             
  380.         case khBKColorMenuID:    
  381.             CheckItem (gtheMenus[khBKColorMenu],gBKColor.menuIndex,false);
  382.             SelectBKColor(theItem);    
  383.             CheckItem (gtheMenus[khBKColorMenu],gBKColor.menuIndex,true);
  384.             break;
  385.  
  386.         case khOPColorMenuID:    
  387.             CheckItem (gtheMenus[khOPColorMenu],gOPColor.menuIndex,false);
  388.             SelectOPColor(theItem);    
  389.             CheckItem (gtheMenus[khOPColorMenu],gOPColor.menuIndex,true);
  390.             break;
  391.  
  392.         case khHiliteMenuID    :    
  393.             CheckItem (gtheMenus[khHiliteMenu],gHiliteColor.menuIndex,false);
  394.             SelectHiliteColor(theItem);    
  395.             CheckItem (gtheMenus[khHiliteMenu],gHiliteColor.menuIndex,true);
  396.             break;
  397.         }
  398.     HiliteMenu(0);                    
  399. }
  400.  
  401.  
  402. /*--------------------------------------------------------------------------------------*/
  403. void DoGrowWindow(WindowPtr  theWindow, EventRecord  *theEvent)
  404. {
  405.     long    newSize;
  406.     Point    newDimen, oldDimen;
  407.     
  408.     
  409.     if (theWindow != FrontWindow()) 
  410.         SelectWindow(theWindow);
  411.     else
  412.         SetPort(theWindow);
  413.         
  414.     newSize = GrowWindow(theWindow,theEvent->where,&qd.screenBits.bounds);
  415.     
  416.     if (newSize != 0)  {
  417.         SetCursor(*GetCursor(watchCursor));
  418.  
  419.         newDimen.h = LoWord(newSize);
  420.         newDimen.v = HiWord(newSize);
  421.         
  422.         if ((theWindow == gWList[kSrcWindow].window) || (theWindow == gWList[kMskWindow].window)) {
  423.             SetPort(gWList[kSrcWindow].window);
  424.             if (ResizeTestWindow(&newDimen,kSrcWindow)) { 
  425.                 oldDimen.h = gWList[kSrcWindow].window->portRect.right  - gWList[kSrcWindow].window->portRect.left;
  426.                 oldDimen.v = gWList[kSrcWindow].window->portRect.bottom - gWList[kSrcWindow].window->portRect.top;
  427.  
  428.                 SetPort(gWList[kMskWindow].window);
  429.                 if (ResizeTestWindow(&newDimen,kMskWindow))  {
  430.                     SizeWindow(gWList[kMskWindow].window,newDimen.h,newDimen.v,false);
  431.                     SizeWindow(gWList[kSrcWindow].window,newDimen.h,newDimen.v,false);
  432.                     }
  433.                 else {
  434.                     SetPort(gWList[kSrcWindow].window);
  435.                     ResizeTestWindow(&oldDimen,kSrcWindow);
  436.                     }
  437.                 }
  438.             }
  439.  
  440.         if ((theWindow == gWList[kDstWindow].window) || (theWindow == gWList[kBitWindow].window)) {
  441.             SetPort(gWList[kDstWindow].window);
  442.             if (ResizeTestWindow(&newDimen,kDstWindow))  {
  443.                 oldDimen.h = gWList[kDstWindow].window->portRect.right  - gWList[kDstWindow].window->portRect.left;
  444.                 oldDimen.v = gWList[kDstWindow].window->portRect.bottom - gWList[kDstWindow].window->portRect.top;
  445.                 
  446.                 SetPort(gWList[kBitWindow].window);
  447.                 if (ResizeTestWindow(&newDimen,kBitWindow))  {
  448.                     SizeWindow(gWList[kBitWindow].window,newDimen.h,newDimen.v,false);
  449.                     SizeWindow(gWList[kDstWindow].window,newDimen.h,newDimen.v,false);
  450.                     UpdateRgnSettings();
  451.                     }
  452.                 else {
  453.                     SetPort(gWList[kDstWindow].window);
  454.                     ResizeTestWindow(&oldDimen,kDstWindow);
  455.                     }
  456.                 }
  457.             }
  458.                 
  459.         SetPort(theWindow);
  460.                         
  461.         DrawBuffer(kBitWindow);
  462.         DrawWindow(kSrcWindow);
  463.         DrawWindow(kMskWindow);
  464.         DrawWindow(kDstWindow);
  465.         DrawWindow(kBitWindow);
  466.         
  467.         InitCursor();
  468.         }
  469. }
  470.  
  471.  
  472. /*--------------------------------------------------------------------------------------*/
  473. short abs(short    a)
  474. {
  475.     return((a<0)?-a:a);
  476. }
  477.  
  478. /*--------------------------------------------------------------------------------------*/
  479. Boolean AlmostEqualPt(Point *pt1, Point *pt2, short tolerance)
  480. /*
  481. //     AlmostEqualPt() determines if two points are equal within the specified tolerance.
  482. */
  483. {
  484.     return ((abs(pt2->h - pt1->h) < tolerance) && (abs(pt2->v - pt1->v) < tolerance));
  485. }
  486.  
  487. /*--------------------------------------------------------------------------------------*/
  488. void DoMouseDown(EventRecord  *theEvent)
  489. {
  490.     short        thePart;
  491.     WindowPtr    theWindow;
  492.     register    i;
  493.  
  494.  
  495.       gDoubleClick  = ((theEvent->when - gLastTime) <= GetDblTime());
  496.     gDoubleClick  = ( (gDoubleClick) && AlmostEqualPt(&gLastPoint,&theEvent->where,3));
  497.  
  498.     thePart = FindWindow(theEvent->where, &theWindow);
  499.     switch ( thePart )  {
  500.         case inMenuBar:    
  501.            AdjustMenus();
  502.            DoMenuCommand(MenuSelect(theEvent->where));
  503.            break;
  504.            
  505.         case inSysWindow:        
  506.            SystemClick( theEvent, theWindow );
  507.            break;
  508.            
  509.         case inContent:
  510.             if (theWindow != FrontWindow()) 
  511.                 SelectWindow(theWindow);
  512.             else  {
  513.                 SetPort(theWindow);
  514.                 if (gDoubleClick)  
  515.                     for (i=kSrcWindow; i<=kBitWindow;  i++)
  516.                         if (theWindow == gWList[i].window)
  517.                             if (i<kBitWindow)
  518.                                 ChangeWindowAttributes(i);
  519.                             else
  520.                                 SysBeep(10);
  521.                 }
  522.                break;
  523.            
  524.         case inDrag:                
  525.             DragWindow(theWindow,theEvent->where,&qd.screenBits.bounds);
  526.             if (gUseScreenBits)  {
  527.                 for (i=kSrcWindow; i<=kDstWindow;  i++)
  528.                     DrawWindow(i);
  529.                 DrawBuffer(kBitWindow);
  530.                 DrawWindow(kBitWindow);
  531.                 }
  532.             break;
  533.            
  534.         case inGrow:
  535.             DoGrowWindow(theWindow, theEvent);
  536.                break;
  537.            
  538.         case inZoomIn:
  539.         case inZoomOut:
  540.             if ( TrackBox(theWindow, theEvent->where, thePart) ) 
  541.                {
  542.                 SetPort(theWindow);                
  543.                 ZoomWindow(theWindow, thePart, true);    
  544.                 InvalRect(&theWindow->portRect);    
  545.                }
  546.             break;
  547.         }
  548.     
  549.       gLastTime  = theEvent->when;
  550.       gLastPoint = theEvent->where;
  551. }
  552.  
  553.  
  554. /*--------------------------------------------------------------------------------------*/
  555. void DoKeyDown( theEvent )
  556.     EventRecord    *theEvent;
  557. {
  558.     char        theKey;
  559.  
  560.     gCmdOn    = ( theEvent->modifiers & cmdKey );
  561.     theKey     = theEvent->message & charCodeMask;
  562.  
  563.     if ((gCmdOn) && (theEvent->what == keyDown))  {
  564.         AdjustMenus();                        
  565.         DoMenuCommand( MenuKey(theKey) );
  566.         }
  567. }
  568.  
  569.  
  570. /*--------------------------------------------------------------------------------------*/
  571. void DoUpdate(EventRecord    *theEvent)
  572. {
  573.     WindowPtr    theWindow;
  574.  
  575.     theWindow     = (WindowPtr)theEvent->message;
  576.     
  577.     if (theWindow != nil)  {
  578.         BeginUpdate(theWindow);
  579.         
  580.         if (theWindow == gWList[kSrcWindow].window)
  581.             DrawWindow(kSrcWindow);
  582.         else if (theWindow == gWList[kMskWindow].window) 
  583.             DrawWindow(kMskWindow);
  584.         else if (theWindow == gWList[kDstWindow].window) 
  585.             DrawWindow(kDstWindow);
  586.         else if (theWindow == gWList[kBitWindow].window) 
  587.             DrawWindow(kBitWindow);
  588.         
  589.         EndUpdate(theWindow);
  590.         }
  591. }
  592.  
  593.  
  594. /*--------------------------------------------------------------------------------------*/
  595. void DoEvent(EventRecord  *theEvent)
  596. {
  597.     switch (theEvent->what)  {
  598.         case nullEvent:
  599.             break;
  600.     
  601.         case mouseDown:    
  602.             DoMouseDown(theEvent);    
  603.             break;
  604.             
  605.         case keyDown:
  606.         case autoKey:    
  607.             DoKeyDown(theEvent);
  608.             break;
  609.             
  610.         case activateEvt:
  611.             InitCursor();
  612.             break;
  613.             
  614.         case updateEvt:
  615.             DoUpdate(theEvent); 
  616.             break;
  617.             
  618.         case diskEvt:
  619.             break;
  620.         }
  621. } 
  622.  
  623.  
  624.  
  625. /*--------------------------------------------------------------------------------------*/
  626. void MainLoop()
  627. {
  628.     EventRecord        theEvent;
  629.  
  630.     do  {
  631.         if (gWNEAvailable)
  632.             WaitNextEvent(everyEvent, &theEvent, LONG_MAX, nil);
  633.         else  {
  634.             SystemTask();
  635.             GetNextEvent(everyEvent, &theEvent);
  636.             }
  637.         
  638.         DoEvent(&theEvent);
  639.         
  640.         } while (! gFinished);
  641.         
  642. }
  643.  
  644.  
  645. /*--------------------------------------------------------------------------------------*/
  646. main()
  647. {
  648.     SysEnvRec    theWorld;
  649.     
  650.             /*  Perform standard mac initialization. */            
  651.     InitMac();        
  652.     
  653.  
  654.     SysEnvirons(1, &theWorld);
  655.     
  656.     
  657.     if (theWorld.systemVersion < 0x0700)  {
  658.         NeedSystem7Dlog();
  659.         ExitToShell();
  660.         }    
  661.  
  662.     
  663.     InitTestGlobals();
  664.     InitAppMenus();
  665.                 
  666.             /*  Initialize all of the app's windows' structures. */            
  667.     InitTestWindowAttributes();
  668.     InitColorSettings();
  669.     InitRgnSettings();
  670.     
  671.             /*  If there is not enough memory to bring up windows exit. */            
  672.     if (CreateTestWindows())     
  673.         MainLoop();
  674.         
  675.     DisposeRgnSettings();
  676.     DisposeTestWindows();
  677.     ExitToShell();
  678. }
  679.